package com.atguigu.day07.HomeWork;

import java.util.Arrays;

/**
 * @version 1.0
 * @Author 马冰
 * @Date 2024/11/6 20:23
 * @注释
 */
public class HomeWork3 {
    //- int sum(int[] arr)：求所有元素总和
    public int sum(int[] arr) {
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        return sum;
    }
    //- int max(int[] arr)：求所有元素的最大值
    public int max(int[] arr) {
        int max = arr[0];
        for (int i : arr) {
            max = Math.max(max, i);
        }
        return max;
    }
    //- int indexOf(int[] arr, int value)：查找value在arr数组中第一次出现的下标，如果不存在返回-1
    public int indexOf(int[] arr, int value) {
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) return i;
        }
        return -1;
    }
    //- int lastIndexOf(int[] arr, int value)：查找value在arr数组中最后一次出现的下标，如果不存在返回-1
    public int lastIndexOf(int[] arr, int value) {
        for (int i = arr.length - 1; i >= 0; i--) {
            if (arr[i] == value) return i;
        }
        return -1;
    }
    //- int valueCount(int[] arr, int value)：查找value在arr数组中出现的次数，如果不存在返回0
    public int valueCount(int[] arr, int value) {
        int age = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == value) age++;
        }
        return age;
    }
    //- void sort(int[] arr)：实现元素从小到大排序
    public void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
        System.out.println("从小到大排序的顺序是：" + Arrays.toString(arr));
    }
    //- void reverse(int[] arr, int start, int end)：反转[start,end]范围内的元素
    public void reverse(int[] arr, int start, int end) {
        for (int i = start, j = end; i <= j; i++, j--) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
        System.out.println("反转之后的数组：" + Arrays.toString(arr));
    }
    //- int[] copyOf(int[] arr, int newLength)：复制arr数组，新数组的长度newLength。
    // 如果newLength<=arr.length，则复制arr数组的[0, newLength-1]范围的元素，
    // 如果newLength>arr.length，则复制arr数组的所有元素到新数组，剩下的元素则默认就可以。
    public int[] copyOf(int[] arr, int newLength) {
        int[] copy = new int[newLength];
        if(newLength <= arr.length){
            for(int i = 0; i < newLength; i++){
                copy[i] = arr[i];
            }
        }else{
            copy = arr;
        }
        return copy;
    }
    //- boolean equals(int[] arr1, int[] arr2)：
    // 判断两个数组的长度和元素是否都相等，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。
    public boolean equals(int[] arr1, int[] arr2) {
        if(arr1.length != arr2.length){
            return false;
        }else {
            for (int i = 0; i < arr1.length; i++) {
                if(arr1[i] != arr2[i]){
                    return false;
                }
            }
        }
        return true;
    }
    //- void fill(int[] arr, int start, int end,  int value) ：将arr数组[start,end]范围的元素赋值为value。
    public void fill(int[] arr, int start, int end,  int value){
        for(int i = start; i <= end; i++){
            arr[i] = value;
        }
        System.out.println("赋值后的值为" + Arrays.toString(arr));
    }
    //- String toString(int[] arr)：将元素拼接为"{元素1，元素2，......}"的字符串返回。
    public String toString(int[] arr){
        String temp = "";
        for(int i = 0; i < arr.length; i++){
            if(i == arr.length - 1){
                temp += arr[i];
            }else {
                temp += arr[i] + ", ";
            }
        }
        return "{" + temp + "}";
    }
}

class HomeWork3Test{
    public static void main(String[] args) {
        HomeWork3 obj = new HomeWork3();
        int[] arr = {1,2,10,4,5,10,7,8,9,10};
//        - int sum(int[] arr)：求所有元素总和
        System.out.println("求所有元素总和：" + obj.sum(arr));

//- int max(int[] arr)：求所有元素的最大值
        System.out.println("最大值：" + obj.max(arr));

//- int indexOf(int[] arr, int value)：查找value在arr数组中第一次出现的下标，如果不存在返回-1
        System.out.println("该数第一次出现的下标为：" + obj.indexOf(arr,10));

//- int lastIndexOf(int[] arr, int value)：查找value在arr数组中最后一次出现的下标，如果不存在返回-1
        System.out.println("该数最后一次出现的下标为：" + obj.lastIndexOf(arr,10));

//- int valueCount(int[] arr, int value)：查找value在arr数组中出现的次数，如果不存在返回0
        System.out.println("该数一共出现了" + obj.valueCount(arr, 10));

//- void sort(int[] arr)：实现元素从小到大排序
        obj.sort(arr);

//- void reverse(int[] arr, int start, int end)：反转[start,end]范围内的元素
        obj.reverse(arr, 1, 5);
//- int[] copyOf(int[] arr, int newLength)：复制arr数组，新数组的长度newLength。如果newLength<=arr.length，则复制arr数组的[0, newLength-1]范围的元素，如果newLength>arr.length，则复制arr数组的所有元素到新数组，剩下的元素则默认就可以。
        System.out.println("复制后的数组是：" + Arrays.toString(obj.copyOf(arr, 5)));
//- boolean equals(int[] arr1, int[] arr2)：判断两个数组的长度和元素是否都相等，如果两个数组以相同顺序包含相同的元素，则两个数组是相等的。
        int[] arr1 = {1,5,6,8,4,6};
        int[] arr2 = {1,5,6,8,4,6};
        System.out.println("两个数组是否相等：" + obj.equals(arr1, arr2));
//- void fill(int[] arr, int start, int end,  int value) ：将arr数组[start,end]范围的元素赋值为value。
        obj.fill(arr, 2, 5, 10);
//- String toString(int[] arr)：将元素拼接为"{元素1，元素2，......}"的字符串返回。
        System.out.println("拼接后的结果是：" + obj.toString(arr));

    }
}
